Changed deleteUrlList from CopyOnWriteArrayList to ArrayList since all access
is already protected by synchronized(indexUpdateCallback) blocks. CopyOnWriteArrayList
creates a copy on every write operation which is unnecessary overhead when synchronization
is already in place.

Changes:
- Replaced CopyOnWriteArrayList with ArrayList for deleteUrlList
- Added synchronized block in commit() method for consistency
- Updated javadoc to clarify synchronization strategy

This improves performance for batch delete operations by eliminating unnecessary
array copying on each URL addition.

Fixed two failing tests that were using 'echo' commands which complete
almost instantly, making it impossible to verify process running state:

1. test_startProcess_replaceExistingProcess:
   - Changed from 'echo' to 'sleep 10' commands
   - Added proper wait time before checking process state
   - Added verification that only one process exists for the session

2. test_destroyProcess_withRunningProcess:
   - Changed from 'echo' to 'sleep 10' command
   - Simplified polling logic - just wait 100ms for process to start
   - Updated exit code assertion (forcibly destroyed processes may have non-zero exit codes)

These changes ensure the tests can reliably verify that processes are running
before attempting to check their state or destroy them.

Added extensive test coverage for the thread safety improvements made to
the data store handling layer.

DataStoreFactoryTest additions:
- test_add_concurrentAccess: Verifies ConcurrentHashMap handles concurrent additions
- test_getDataStore_concurrentWithAdd: Tests concurrent read/write operations
- test_getDataStoreNames_concurrentAccess: Verifies synchronized method correctness
- test_volatileFields_visibility: Ensures volatile fields are visible across threads
- test_cacheRefresh_withConcurrentReads: Validates cache refresh with concurrent access
- test_nullSafety_concurrentAccess: Tests null handling under concurrent load

AbstractDataStoreTest additions:
- test_aliveField_volatileVisibility: Verifies volatile alive field visibility
- test_stop_volatileVisibility: Tests stop() method sets alive and is visible
- test_stop_concurrentAccess: Validates concurrent calls to stop()
- test_aliveField_concurrentReadWrite: Tests concurrent read/write of alive field
- test_getName_concurrentAccess: Verifies getName() is thread-safe

FileListIndexUpdateCallbackImplTest additions:
- test_deleteUrlList_synchronizedAccess: Validates ArrayList with synchronized blocks
- test_deleteUrlList_concurrentReads: Tests concurrent reads from deleteUrlList
- test_deleteUrlList_clearOperation: Verifies clear() operation thread safety
- test_deleteUrlList_iteration: Tests iteration with proper synchronization
- test_deleteUrlList_isEmptyCheck: Validates isEmpty() check under concurrent access

These tests verify:
1. ConcurrentHashMap correctly handles concurrent operations in DataStoreFactory
2. Volatile fields ensure proper visibility across threads
3. Synchronized methods prevent race conditions during cache refresh
4. ArrayList works correctly when all access is properly synchronized
5. No ConcurrentModificationException occurs in any concurrent scenario

All tests use minimal or no sleep to maintain fast test execution time.

Based on feedback that dataStoreMap is not accessed by multiple threads,
reverted the ConcurrentHashMap change back to LinkedHashMap.

Changes:
- Reverted dataStoreMap from ConcurrentHashMap to LinkedHashMap
- Removed ConcurrentHashMap import
- Removed dataStoreMap-related concurrency tests:
  * test_add_concurrentAccess
  * test_getDataStore_concurrentWithAdd
  * test_nullSafety_concurrentAccess

Kept volatile fields and synchronized getDataStoreNames():
- lastLoadedTime and dataStoreNames remain volatile (for cache visibility)
- getDataStoreNames() remains synchronized (for cache refresh safety)
- Related tests for getDataStoreNames() concurrency are maintained

The dataStoreMap is accessed in single-threaded context during application
initialization and data store registration.